#include <iostream>
#include <cmath>
using namespace std;


//完全数计算
bool isPerfect(int n)
{
    int nsqrt = sqrt(n);
    int sum = 1;
    for (int i = 2; i<=nsqrt; ++i)
    {
        if (n%i == 0)
        {
            sum += i;
            if (n/i != i)
                sum += (n/i);
            
        }
    }
    return (sum == n);
}

int getPerfectNum(int n)
{
    if (n <= 1)
    {
        return 0;
    }
    
    int ans = 0;
    for (int i = 2; i<=n; ++i)
    {
        if (isPerfect(i))
            ++ans;
    }
    return ans;
}

int main()
{
    int n;
    cin >> n;
    
    cout << getPerfectNum(n) << endl;
    
    return 0;
}

// #include <iostream>
// #include <vector>
// #include <unordered_set>

// namespace wyd
// {

//     template <class T>
//     struct SingleListNode
//     {
//         T _val;
//         SingleListNode* _next;
        
//         SingleListNode(int val)
//             : _val(val)
//             , _next(nullptr)
//         {}
//     };
    
//     template <class T>
//     class SingleList
//     {
//         typedef SingleListNode<T> Node;
//         typedef SingleList<T> Self;

//     public:


//         friend Self mergeList(Self& l1, Self& l2);


//         // {
//         //     std::unordered_set<int> _st;
//         //     auto cur1 = l1._head->_next;
//         //     while (cur1 != nullptr)
//         //     {
//         //         _st.insert(cur1->_val);
//         //         cur1 = cur1->_next;
//         //     }
//         //     auto cur2 = l2._head->_next;
//         //     while (cur2 != nullptr)
//         //     {
//         //         _st.insert(cur2->_val);
//         //         cur2 = cur2->_next;
//         //     }

//         //     return SingleList(_st.begin(), _st.end());
//         // }

//     private:
//         void InitSingleList()
//         {
//             _head = new Node(0);
//         }
//     public:
//         SingleList() { InitSingleList(); }
//         ~SingleList()
//         {
//             while (_head)
//             {
//                 Node* next = _head->_next;
//                 delete _head;
//                 _head = next;
//             }
//         }

//         template <class InputIterator>
//         SingleList(InputIterator first, InputIterator last)
//         {
//             InitSingleList();
//             InputIterator it = first;
//             Node* cur = _head;
//             while (it != last)
//             {
//                 cur->_next = new Node(*it);
//                 cur = cur->_next;
//                 ++it;
//             }
//         }

//         SingleList(SingleList&& sl)
//         {
//             std::swap(_head, sl._head);
//         }

//         void Print()
//         {
//             Node* cur = _head->_next;
//             while (cur != nullptr)
//             {
//                 std::cout << cur->_val << " ";
//                 cur = cur->_next;
//             }
//             std::cout << std::endl;
//         }

//     private:
//         Node* _head;
//     };

//     template <class T>
//     typename SingleList<T>::Self mergeList(typename SingleList<T>::Self& l1, typename SingleList<T>::Self& l2)
//     {
//         std::unordered_set<T> _st;
//         auto cur1 = l1._head->_next;
//         while (cur1 != nullptr)
//         {
//             _st.insert(cur1->_val);
//             cur1 = cur1->_next;
//         }
//         auto cur2 = l2._head->_next;
//         while (cur2 != nullptr)
//         {
//             _st.insert(cur2->_val);
//             cur2 = cur2->_next;
//         }

//         return SingleList<T>(_st.begin(), _st.end());
//     }

// }



// int main()
// {

// 	std::vector<int> arr1({ 1,6,4,2 });
//     std::vector<int> arr2({ 2,3,4,5 });

//     wyd::SingleList<int> l1(arr1.begin(), arr1.end());
//     wyd::SingleList<int> l2(arr2.begin(), arr2.end());

//     mergeList(l1, l2);

//     //ans.Print();

//     return 0;
// }

// #include <iostream>

// template<typename T>
// class Number
// {
// public:
//     Number(T v)
//         : _val(v)
//     {}
//     ~Number() {}

// private:
//     T _val;

// public:

//     friend void print(const Number<T>& n);
// };

// template <typename T>

// void print(const Number<T>& n)
// {
//     std::cout << n;
// }

// int main()
// {
//     return 0;
// }